// pages/menu/menu.js
import {
  checkPageLogin
} from '../../utils/login-check.js'
import {
  productAPI,
  userAPI
} from '../../utils/api.js'

const app = getApp()

Page({
  data: {
    showLoginModal: false,
    categories: [{
      id: 'all',
      name: '全部'
    }],
    loading: false,
    productsLoading: false,
    products: [],
    currentCategory: 0,
    currentPage: 1,
    hasMore: true,

    // 购物车相关
    cart: [],
    cartTotal: {
      totalQuantity: 0,
      totalPrice: 0
    },
    showCart: false,

    // 商品详情弹窗相关
    showProductDetail: false,
    currentProduct: null,
    selectedSku: null,
    productQuantity: 1,
    detailTranslateY: 0,
    detailOpacity: 1,
    detailLoading: false,

    // 关于我们弹窗
    showAboutModal: false,

    // 桌号相关
    tableNo: '',
    tableId: null,
    tableInfo: {
      name: '',
      area: ''
    },

    // 加单相关
    processingTrade: null
  },

  onLoad(options) {
    this.pendingCheckout = false // 初始化待结算标记

    // 处理桌位参数
    if (options.tableId) {
      this.setData({
        tableId: parseInt(options.tableId)
      })
      // 获取桌位详情
      this.loadTableDetail(parseInt(options.tableId))
    } else if (options.tableNo) {
      this.setData({
        tableNo: options.tableNo
      })
    } else {
      // 检查本地存储是否有桌号
      const savedTableNo = wx.getStorageSync('tableNo')
      if (savedTableNo) {
        this.setData({
          tableNo: savedTableNo
        })
      }
    }

    // 从本地存储恢复购物车数据
    const savedCart = wx.getStorageSync('cart') || []
    if (savedCart.length > 0) {
      this.setData({
        cart: savedCart
      })
      // 同步到全局数据
      app.globalData.cart = savedCart
    }

    this.updateCartTotal()
    this.loadCategories()
    this.loadProducts()
  },

  onShow() {
    if (typeof this.getTabBar === 'function' && this.getTabBar()) {
      this.getTabBar().setData({
        selected: 1
      })
    }

    // 桌号 
    const tableId = wx.getStorageSync('tableId')
    if (tableId) {
      this.setData({
        tableId: tableId
      })

      // 获取桌位详情
      this.loadTableDetail(tableId)

      // 同步购物车状态
      this.syncCartData()
      this.updateCartTotal()
      // this.loadCategories()
      // this.loadProducts()
    }

    // 检查登录状态
    // checkPageLogin()
  },

  // 图片区域点击事件
  // 点击预览图片
  onImagePreview() {
    console.log('图片区域点击事件')
    wx.previewImage({
      urls: [this.data.currentProduct.image],
      current: this.data.currentProduct.image
    })
  },

  // 下拉刷新
  onPullDownRefresh() {
    Promise.all([
      this.loadCategories(),
      this.loadProducts(true) // 重置加载
    ]).then(() => {
      wx.stopPullDownRefresh()
    }).catch(() => {
      wx.stopPullDownRefresh()
    })
  },

  // 加载商品分类列表
  async loadCategories() {
    try {
      this.setData({
        loading: true
      })

      const result = await productAPI.getCategoryList({
        page: 1,
        pageSize: 50
      })

      console.log('商品分类列表:', result)
      if (result && result.list && Array.isArray(result.list)) {
        // 添加"全部"选项到分类列表开头
        const categories = [{
          id: 'all',
          name: '全部'
        },
        ...result.list.map(item => ({
          id: item.id,
          name: item.name
        }))
        ]

        this.setData({
          categories,
          loading: false
        })

        console.log('商品分类加载成功:', categories)
      } else {
        console.error('商品分类数据格式错误:', result)
        this.setData({
          loading: false
        })
        this.showErrorToast('分类数据格式错误')
      }
    } catch (error) {
      console.error('加载商品分类失败:', error)
      this.setData({
        loading: false
      })

      // 检查是否是401错误
      if (error.statusCode === 401 || error.code === 401) {
        this.showLoginModal()
        return
      }

      // 如果接口失败，使用默认分类
      const defaultCategories = [{
        id: 'all',
        name: '全部'
      },
      {
        id: 'ipa',
        name: 'IPA'
      },
      {
        id: 'lager',
        name: '拉格'
      },
      {
        id: 'wheat',
        name: '小麦'
      },
      {
        id: 'stout',
        name: '世涛'
      }
      ]
      this.setData({
        categories: defaultCategories
      })
      this.showErrorToast('网络异常，使用默认分类')
    }
  },

  // 加载商品列表
  async loadProducts(reset = false) {
    try {
      if (reset) {
        this.setData({
          products: [],
          currentPage: 1,
          hasMore: true
        })
      }

      if (!this.data.hasMore || this.data.productsLoading) {
        return
      }

      this.setData({
        productsLoading: true
      })

      const categoryId = this.data.categories[this.data.currentCategory] ? this.data.categories[this.data.currentCategory].id : 'all'
      const params = {
        category: categoryId === 'all' ? '' : categoryId,
        page: this.data.currentPage,
        pageSize: 20,
        status: 1
      }

      const result = await productAPI.getProductList(params)
      console.log('商品列表:', result)

      if (result && result.list && Array.isArray(result.list)) {
        const newProducts = result.list.map(item => {
          // 处理SKU列表，为每个SKU添加显示名称
          const skuList = (item.variants || []).map(sku => ({
            ...sku,
            displayName: this.getSkuDisplayName(sku, item.attributes || [])
          }))

          return {
            id: item.id,
            name: item.title,
            title: item.title,
            description: item.description || '',
            price: item.price,
            image: item.image,
            images: item.images || [],
            stock: item.stock,
            sales: item.sales,
            canBuy: item.canBuy,
            cartQuantity: 0,
            hasSku: skuList.length > 0,
            skuList: skuList,
            attributes: item.attributes || [],
            tags: item.tags || [] // 添加标签字段
          }
        })

        const products = reset ? newProducts : [...this.data.products, ...newProducts]
        const hasMore = result.pagination &&
          this.data.currentPage < Math.ceil(result.pagination.total / result.pagination.pageSize)

        this.setData({
          products,
          currentPage: this.data.currentPage + 1,
          hasMore,
          productsLoading: false
        })

        console.log('商品列表加载成功:', newProducts.length, '个商品')
      } else {
        console.error('商品列表数据格式错误:', result)
        this.setData({
          productsLoading: false
        })
        this.showErrorToast('商品数据格式错误')
      }
    } catch (error) {
      console.error('加载商品列表失败:', error)
      this.setData({
        productsLoading: false
      })

      // 检查是否是401错误
      if (error.statusCode === 401 || error.code === 401) {
        this.showLoginModal()
        return
      }

      this.showErrorToast('网络异常，加载商品失败')
    }
  },

  // 分类切换
  onCategoryTap(e) {
    const index = e.currentTarget.dataset.index
    this.setData({
      currentCategory: index,
      products: [],
      currentPage: 1,
      hasMore: true
    })
    this.loadProducts(true) // 重置加载新分类的商品
  },

  // 加载更多商品
  onLoadMore() {
    if (this.data.hasMore && !this.data.productsLoading) {
      this.loadProducts(false) // 不重置，追加加载
    }
  },

  // 商品详情点击 - 获取商品详情并显示弹窗
  onProductDetail(e) {
    const productId = e.currentTarget.dataset.id
    const product = this.data.products.find(p => p.id === productId)

    // 显示加载状态
    this.setData({
      showProductDetail: true,
      detailLoading: true,
      currentProduct: product,
      selectedSku: null,
      productQuantity: 1,
      detailTranslateY: 0
    })

    // 获取商品详情
    productAPI.getProductDetail(productId).then(response => {
      console.log('获取商品详情成功:', response)
      const detailProduct = response.data || response.info || response

      // 处理SKU列表，为每个SKU添加显示名称
      const skuList = (detailProduct.variants || []).map(sku => ({
        ...sku,
        displayName: this.getSkuDisplayName(sku, detailProduct.attributes || [])
      }))

      // 更新商品信息
      this.setData({
        currentProduct: {
          ...product,
          ...detailProduct,
          hasSku: skuList.length > 0,
          skuList: skuList,
          attributes: detailProduct.attributes || [],
          tags: detailProduct.tags || [] // 添加标签字段
        },
        selectedSku: skuList.length > 0 ? skuList[0] : null,
        detailLoading: false
      })
    }).catch(error => {
      console.error('获取商品详情失败:', error)
      // 获取详情失败，使用基础信息
      const skuList = (product.skuList || []).map(sku => ({
        ...sku,
        displayName: this.getSkuDisplayName(sku, product.attributes || [])
      }))

      this.setData({
        currentProduct: {
          ...product,
          hasSku: skuList.length > 0,
          skuList: skuList,
          attributes: product.attributes || [],
          tags: product.tags || [] // 添加标签字段
        },
        selectedSku: skuList.length > 0 ? skuList[0] : null,
        detailLoading: false
      })

      wx.showToast({
        title: '获取商品详情失败',
        icon: 'none'
      })
    })
  },

  // 关闭商品详情弹窗
  onCloseProductDetail() {
    // 重置触摸状态
    this.resetTouchState()
    
    // 先执行从上到下的过渡动画
    this.setData({
      detailTranslateY: 1000
    })

    // 延迟关闭弹窗
    setTimeout(() => {
      this.setData({
        showProductDetail: false,
        currentProduct: null,
        selectedSku: null,
        productQuantity: 1,
        detailTranslateY: 0,
        detailLoading: false
      })
    }, 300)
  },

  // 商品详情弹窗触摸开始 - 只在图片区域
  onDetailTouchStart(e) {
    // 记录触摸开始位置和时间
    const touch = e.touches[0]
    this.detailTouchStartY = touch.clientY
    this.detailTouchStartX = touch.clientX
    this.detailTouchStartTime = Date.now()
    this.detailTouchInImageArea = true
    
    console.log('Touch start:', { x: touch.clientX, y: touch.clientY })
    
    // 阻止事件冒泡，避免触发其他事件
    e.stopPropagation()
  },

  // 商品详情弹窗触摸移动 - 只在图片区域
  onDetailTouchMove(e) {
    if (!this.detailTouchStartY || !this.detailTouchInImageArea) return

    const currentY = e.touches[0].clientY
    const currentX = e.touches[0].clientX
    const deltaY = currentY - this.detailTouchStartY
    const deltaX = Math.abs(currentX - this.detailTouchStartX)

    console.log('Touch move:', { deltaY, deltaX, ratio: deltaY / deltaX })

    // 确保是垂直滑动（垂直距离大于水平距离的2倍）
    if (deltaY > deltaX * 2 && deltaY > 0) {
      // 阻止默认行为和事件冒泡
      e.preventDefault()
      e.stopPropagation()
      
      // 添加视觉反馈，改变位置
      const translateY = Math.min(deltaY * 0.5, 200) // 最大移动200px

      this.setData({
        detailTranslateY: translateY
      })
    }
  },

  // 商品详情弹窗触摸结束 - 只在图片区域
  onDetailTouchEnd(e) {
    if (!this.detailTouchStartY || !this.detailTouchInImageArea) {
      this.resetTouchState()
      return
    }

    const currentY = e.changedTouches[0].clientY
    const currentX = e.changedTouches[0].clientX
    const deltaY = currentY - this.detailTouchStartY
    const deltaX = Math.abs(currentX - this.detailTouchStartX)
    const deltaTime = Date.now() - this.detailTouchStartTime

    console.log('Touch end:', { deltaY, deltaX, deltaTime, shouldClose: deltaY > 100 || (deltaY > 50 && deltaTime < 300) })

    // 确保是垂直滑动且向下滑动
    if (deltaY > deltaX * 2 && deltaY > 0) {
      // 如果向下滑动距离超过100px或速度足够快，则关闭弹窗
      if (deltaY > 100 || (deltaY > 50 && deltaTime < 300)) {
        console.log('Closing modal due to swipe')
        // 直接调用关闭方法，它会处理动画
        this.onCloseProductDetail()
      } else {
        console.log('Resetting position')
        // 恢复原位置
        this.setData({
          detailTranslateY: 0
        })
      }
    } else {
      console.log('Not a valid vertical swipe, resetting position')
      // 如果不是有效的垂直滑动，恢复原位置
      this.setData({
        detailTranslateY: 0
      })
    }

    this.resetTouchState()
  },

  // 重置触摸状态
  resetTouchState() {
    this.detailTouchStartY = null
    this.detailTouchStartX = null
    this.detailTouchStartTime = null
    this.detailTouchInImageArea = false
  },

  // 图片区域点击事件（备用关闭方式）
  onImageTap(e) {
    // 如果触摸状态存在，说明正在进行滑动操作，不处理点击
    if (this.detailTouchStartY !== null) {
      return
    }
    
    // 简单的点击关闭逻辑
    console.log('Image tap detected, closing modal')
    this.onCloseProductDetail()
  },

  // SKU选择
  onSkuSelect(e) {
    const skuId = e.currentTarget.dataset.skuId
    const sku = this.data.currentProduct.skuList.find(s => s.id === skuId)
    this.setData({
      selectedSku: sku
    })
  },

  // 弹窗内数量减少
  onDetailQuantityReduce() {
    if (this.data.productQuantity > 1) {
      this.setData({
        productQuantity: this.data.productQuantity - 1
      })
    }
  },

  // 弹窗内数量增加
  onDetailQuantityAdd() {
    const {
      productQuantity
    } = this.data
    const maxQuantity = 99 // 最大购买数量限制

    if (productQuantity < maxQuantity) {
      this.setData({
        productQuantity: productQuantity + 1
      })
    } else {
      wx.showToast({
        title: '已达到最大购买数量',
        icon: 'none'
      })
    }
  },

  // 从详情弹窗加入购物车
  onDetailAddToCart() {
    const {
      currentProduct,
      selectedSku,
      productQuantity
    } = this.data

    // 检查是否需要选择SKU
    if (currentProduct.hasSku && currentProduct.skuList && currentProduct.skuList.length > 0) {
      if (!selectedSku) {
        wx.showToast({
          title: '请选择规格',
          icon: 'none'
        })
        return
      }
    }

    // 添加到购物车
    const cartItem = {
      id: currentProduct.id,
      name: currentProduct.title || currentProduct.name,
      title: currentProduct.title || currentProduct.name,
      price: selectedSku ? selectedSku.price : currentProduct.price,
      image: currentProduct.image,
      images: currentProduct.images || [],
      skuId: selectedSku ? selectedSku.id : null,
      skuName: selectedSku ? this.getSkuName(selectedSku) : null,
      quantity: productQuantity
    }

    this.addToCart(cartItem)
    this.onCloseProductDetail()
  },

  // 获取SKU名称
  getSkuName(sku) {
    if (!sku || !sku.attValues) return ''

    const attNames = sku.attValues.map(att => {
      const attribute = this.data.currentProduct.attributes.find(a => a.id === att.attId)
      if (attribute) {
        const value = attribute.values.find(v => v.id === att.valueId)
        return value ? value.value : ''
      }
      return ''
    }).filter(name => name)

    return attNames.join(' ')
  },

  // 获取SKU显示名称（用于WXML）
  getSkuDisplayName(sku, attributes) {
    if (!sku || !sku.attValues) return '默认规格'

    const attNames = sku.attValues.map(att => {
      const attribute = attributes.find(a => a.id === att.attId)
      if (attribute) {
        const value = attribute.values.find(v => v.id === att.valueId)
        return value ? value.value : ''
      }
      return ''
    }).filter(name => name)

    return attNames.length > 0 ? attNames.join(' ') : '默认规格'
  },

  // 直接加入购物车
  onAddToCart(e) {
    const productId = e.currentTarget.dataset.id
    const product = this.data.products.find(p => p.id === productId)

    if (!product.canBuy) {
      wx.showToast({
        title: '商品暂时无法购买',
        icon: 'none'
      })
      return
    }

    const cartItem = {
      id: product.id,
      name: product.title || product.name,
      title: product.title || product.name,
      price: product.price,
      image: product.image,
      images: product.images || [],
      quantity: 1
    }

    this.addToCart(cartItem)
  },

  // 添加到购物车
  addToCart(cartItem) {
    const {
      cart
    } = this.data
    const existingItem = cart.find(item =>
      item.id === cartItem.id && item.skuId === cartItem.skuId
    )

    if (existingItem) {
      existingItem.quantity += cartItem.quantity
      // 如果原订单项增加了数量，标记为新加
      if (existingItem.isFromOrder) {
        existingItem.isNewItem = true
      }
    } else {
      // 新添加的商品标记为新加
      cartItem.isNewItem = true
      cart.push(cartItem)
    }

    this.setData({
      cart
    }, () => {
      // 同步到全局数据
      app.globalData.cart = cart

      // 保存到本地存储
      wx.setStorageSync('cart', cart)

      this.updateCartTotal()
      this.updateProductCartQuantity()

      wx.showToast({
        title: '已加入购物车',
        icon: 'success'
      })
    })
  },

  // 减少购物车数量
  onReduceQuantity(e) {
    const productId = e.currentTarget.dataset.id
    const {
      cart
    } = this.data
    const item = cart.find(item => item.id === productId)

    if (item) {
      if (item.quantity > 1) {
        item.quantity--
      } else {
        const index = cart.indexOf(item)
        cart.splice(index, 1)
      }

      this.setData({
        cart
      }, () => {
        // 同步到全局数据
        app.globalData.cart = cart

        // 保存到本地存储
        wx.setStorageSync('cart', cart)

        this.updateCartTotal()
        this.updateProductCartQuantity()
      })
    }
  },

  // 增加购物车数量
  onIncreaseQuantity(e) {
    const productId = e.currentTarget.dataset.id
    const {
      cart
    } = this.data
    const item = cart.find(item => item.id === productId)

    if (item) {
      item.quantity++
      this.setData({
        cart
      }, () => {
        // 同步到全局数据
        app.globalData.cart = cart

        // 保存到本地存储
        wx.setStorageSync('cart', cart)

        this.updateCartTotal()
        this.updateProductCartQuantity()
      })
    }
  },

  // 更新商品在购物车中的数量显示
  updateProductCartQuantity() {
    const {
      products,
      cart
    } = this.data
    const updatedProducts = products.map(product => {
      const cartItem = cart.find(item => item.id === product.id)
      return {
        ...product,
        cartQuantity: cartItem ? cartItem.quantity : 0
      }
    })

    this.setData({
      products: updatedProducts
    })
  },

  // 切换购物车显示
  onToggleCart() {
    this.setData({
      showCart: !this.data.showCart
    })
  },

  // 清空购物车
  onClearCart() {
    wx.showModal({
      title: '确认清空',
      content: '确定要清空购物车吗？',
      success: (res) => {
        if (res.confirm) {
          this.setData({
            cart: [],
            showCart: false
          }, () => {
            // 同步到全局数据
            app.globalData.cart = []

            // 清空本地存储
            wx.removeStorageSync('cart')

            this.updateCartTotal()
            this.updateProductCartQuantity()
          })
        }
      }
    })
  },

  // 去结算
  onCheckout() {
    if (this.data.cart.length === 0) {
      wx.showToast({
        title: '购物车为空',
        icon: 'none'
      })
      return
    }

    // 检查登录状态
    const token = wx.getStorageSync('token')

    if (!token) {
      // 未登录，标记待结算状态并显示登录弹窗
      this.pendingCheckout = true
      this.showLoginModal()
      return
    }

    // 没有桌号，提示选择桌号
    if (!this.data.tableId) {
      wx.showToast({
        title: '请选择桌号',
        icon: 'none'
      })
      return
    }

    // 验证用户信息
    userAPI.getUserProfile().then(userInfo => {
      console.log('验证用户信息成功:', userInfo)

      // 检查是否是加单场景
      const isAddOrder = this.data.processingTrade

      // 准备传递给结算页面的数据
      const checkoutData = {
        cart: this.data.cart,
        isAddOrder: isAddOrder
      }

      let checkoutUrl = `/pages/checkout/checkout?data=${encodeURIComponent(JSON.stringify(checkoutData))}`

      // 如果有tableId，添加到URL参数中
      if (this.data.tableId) {
        checkoutUrl += `&tableId=${this.data.tableId}`
      }

      // 如果是加单场景，传递订单号和支付信息
      if (isAddOrder) {
        // 需要先获取订单详情
        userAPI.getTradeDetail(this.data.processingTrade).then(targetOrder => {
          console.log('targetOrder', targetOrder)

          // 更新checkoutData，包含订单支付信息
          checkoutData.orderPayment = targetOrder.payment

          if (targetOrder && targetOrder.no) {
            checkoutUrl = `/pages/checkout/checkout?data=${encodeURIComponent(JSON.stringify(checkoutData))}&orderNo=${targetOrder.no}`
          } else {
            checkoutUrl = `/pages/checkout/checkout?data=${encodeURIComponent(JSON.stringify(checkoutData))}`
          }

          // 如果有tableId，添加到URL参数中
          if (this.data.tableId) {
            checkoutUrl += `&tableId=${this.data.tableId}`
          }

          wx.navigateTo({
            url: checkoutUrl
          })
        }).catch(error => {
          console.error('获取订单详情失败:', error)
          // 即使获取订单详情失败，也跳转到结算页面
          wx.navigateTo({
            url: checkoutUrl
          })
        })
      } else {
        wx.navigateTo({
          url: checkoutUrl
        })
      }
    }).catch(error => {
      console.error('验证用户信息失败:', error)
      // 验证失败，可能是token过期，显示登录弹窗
      this.pendingCheckout = true
      this.showLoginModal()
    })
  },

  // 同步购物车数据
  syncCartData() {
    // 从全局数据同步购物车
    const globalCart = app.globalData.cart || []
    const localCart = this.data.cart || []

    // 如果全局购物车为空，清空本地购物车
    if (globalCart.length === 0 && localCart.length > 0) {
      this.setData({
        cart: []
      })
      console.log('购物车已清空')
    } else if (globalCart.length > 0) {
      // 如果全局购物车有数据，同步到本地
      this.setData({
        cart: globalCart
      })
      console.log('购物车数据已同步:', globalCart.length, '件商品')
    }
  },

  // 更新购物车总计
  updateCartTotal() {
    const {
      cart
    } = this.data
    const totalQuantity = cart.reduce((sum, item) => sum + item.quantity, 0)
    const totalPrice = cart.reduce((sum, item) => sum + (item.price * item.quantity), 0)

    this.setData({
      cartTotal: {
        totalQuantity,
        totalPrice
      }
    })
  },



  // 显示登录弹窗
  showLoginModal() {
    this.setData({
      showLoginModal: true
    })
  },

  // 关闭登录弹窗
  onCloseLoginModal() {
    this.setData({
      showLoginModal: false
    })
  },

  // 登录成功回调
  onLoginSuccess(e) {
    this.setData({
      showLoginModal: false
    })

    // 如果是从结算触发的登录，登录成功后自动跳转到结算页面
    if (this.pendingCheckout) {
      this.pendingCheckout = false

      // 检查是否是加单场景
      const isAddOrder = this.data.processingTrade

      // 准备传递给结算页面的数据
      const checkoutData = {
        cart: this.data.cart,
        isAddOrder: isAddOrder
      }

      let checkoutUrl = `/pages/checkout/checkout?data=${encodeURIComponent(JSON.stringify(checkoutData))}`

      // 如果没有tableId，提示选择桌号
      if (!this.data.tableId) {
        wx.showToast({
          title: '请选择桌号',
          icon: 'none'
        })
        return
      }

      // 如果有tableId，添加到URL参数中
      if (this.data.tableId) {
        checkoutUrl += `&tableId=${this.data.tableId}`
      }

      wx.navigateTo({
        url: checkoutUrl
      })
    }

    wx.showToast({
      title: '登录成功',
      icon: 'success'
    })
  },

  // 显示错误提示
  showErrorToast(message) {
    wx.showToast({
      title: message,
      icon: 'none',
      duration: 2000
    })
  },

  // 显示关于我们弹窗
  showAboutModal() {
    this.setData({
      showAboutModal: true
    })
  },

  // 关闭关于我们弹窗
  onCloseAboutModal() {
    this.setData({
      showAboutModal: false
    })
  },

  // 打开地图
  onOpenMap() {
    const address = '广州市越秀区北京街道盐运西正街25号一楼'
    const latitude = 23.1291 // 广州越秀区的大概坐标
    const longitude = 113.2644

    wx.showActionSheet({
      itemList: ['打开微信地图', '复制地址'],
      success: (res) => {
        if (res.tapIndex === 0) {
          // 打开微信地图
          wx.openLocation({
            latitude: latitude,
            longitude: longitude,
            name: 'OKEYDO TAP ROOM',
            address: address,
            scale: 18
          })
        } else if (res.tapIndex === 1) {
          // 复制地址
          wx.setClipboardData({
            data: address,
            success: () => {
              wx.showToast({
                title: '地址已复制',
                icon: 'success'
              })
            }
          })
        }
      }
    })
  },

  // 加载桌位详情
  async loadTableDetail(tableId) {
    try {
      const tableInfo = await userAPI.getTableDetail(tableId)
      console.log('桌位详情:', tableInfo)

      this.setData({
        tableInfo: {
          name: tableInfo.name,
          area: tableInfo.area
        },
        tableNo: tableInfo.name, // 同时设置桌号显示
        processingTrade: tableInfo.processingTrade || null
      })

      // 保存桌位信息到本地存储
      wx.setStorageSync('tableId', tableId)
      wx.setStorageSync('tableNo', tableInfo.name)

      // 如果有进行中的订单，只保存订单ID，不加载商品信息
      if (tableInfo.processingTrade) {
        console.log('检测到进行中订单:', tableInfo.processingTrade)
      }
    } catch (error) {
      console.error('获取桌位详情失败:', error)

      // 检查是否是401错误
      if (error.statusCode === 401 || error.code === 401) {
        this.showLoginModal()
        return
      }

      wx.showToast({
        title: '获取桌位信息失败',
        icon: 'none'
      })
    }
  },





  // 扫码选择桌号
  onScanTableCode() {
    wx.scanCode({
      success: (res) => {
        wx.removeStorageSync('cart')
        console.log('扫码结果:', res)
        const path = res.path.split('?')[0]
        const params = res.path.split('?')[1]
        const paramsObj = {}
        params.split('&').forEach(item => {
          const [key, value] = item.split('=')
          paramsObj[key] = value
        })
        console.log('paramsObj', paramsObj)
        console.log('path', path)
        if (res.path) {
          // 保存桌号到本地存储
          wx.setStorageSync('tableId', paramsObj.tableId)
          // 跳转到点餐页面并传递桌号参数
          wx.switchTab({
            url: '/' + path,
            query: paramsObj
          })
        }
      },
      fail: (error) => {
        // console.error('扫码失败:', error)
        // wx.showToast({
        //   title: '扫码失败',
        //   icon: 'none'
        // })
      }
    })
  },

  // 清除购物车和桌号缓存
  clearCartAndTableCache() {
    console.log('清除购物车和桌号缓存...')

    try {
      // 清除购物车相关缓存
      wx.removeStorageSync('cart')
      this.globalData.cart = []

      // 清除桌号相关缓存
      wx.removeStorageSync('tableId')
      wx.removeStorageSync('tableNo')

      console.log('购物车和桌号缓存已清除')
    } catch (error) {
      console.error('清除缓存失败:', error)
    }
  },

  onUnload() {
    console.log('menu onUnload')
    // 小程序退出时清除购物车和桌号缓存
    // this.clearCartAndTableCache()
  },

  // 分享
  onShareAppMessage() {
    return {
      title: 'OKEYDO 精酿啤酒',
      path: '/pages/menu/menu'
    }
  }
})